package stack_queue;

import org.checkerframework.checker.units.qual.A;

import javax.security.auth.login.CredentialException;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Deque;
import java.util.LinkedList;

/**
 * 239. 滑动窗口最大值
 *
 * @author Api
 * @date 2023/10/18 0:09
 */
public class Code239_MaximumSlidingWindow {
    // 解法一
    // 自定义数组
    static class MyQueue {
        Deque<Integer> deque = new LinkedList<>();

        // 弹出元素时，比较当前要弹出的数值是否等于队列出口的数值，如果相等则弹出
        // 同时判断队列当前是否为空
        void poll(int val) {
            if (!deque.isEmpty() && val == deque.peek()) {
                deque.poll();
            }
        }

        // 添加元素时，如果要添加的元素大于入口处的元素，就将入口元素弹出
        // 保证队列元素单调递减
        // 比如此时队列元素3,1,2将要入栈，比1大，所以1弹出，此时队列3,2
        void add(int val) {
            while (!deque.isEmpty() && val > deque.getLast()) {
                deque.removeLast();
            }
            deque.add(val);
        }

        // 队列队顶元素始终为最大值
        int peek() {
            return deque.peek();
        }
    }

    public int[] maxSlidingWindow(int[] nums, int k) {
        if (nums.length == 1) {
            return nums;
        }
        int len = nums.length - k + 1;
        // 存放结果元素的数组
        int[] res = new int[len];
        int num = 0;
        // 自定义队列
        MyQueue myQueue = new MyQueue();
        // 先将前k的元素放入队列
        for (int i = 0; i < k; i++) {
            myQueue.add(nums[i]);
        }
        res[num++] = myQueue.peek();
        for (int i = k; i < nums.length; i++) {
            // 滑动窗口移除最前面的元素，移除时判断该元素是否放入队列
            myQueue.poll(nums[i - k]);
            // 滑动窗口加入最后面的元素
            myQueue.add(nums[i]);
            // 记录对应的最大值
            res[num++] = myQueue.peek();
        }
        return res;
    }

    //==================================================================================================================

    // 解法二
    // 利用双端队列手动实现单调队列
    /*用一个单调队列来存储对应的下标，每当窗口滑动的时候，直接取队列的头部指针对应的值放入结果集即可*/
    /*单调队列类似(tail -->)3-->2-->1-->0(-->head)(右边为头节点，元素存的是下标)*/

    public int[] maxSlidingWindow1(int[] nums, int k) {
        Deque<Integer> deque = new ArrayDeque<>();
        int n = nums.length;
        int[] res = new int[n - k + 1];
        int idx = 0;
        for (int i = 0; i < n; i++) {
            // 根据题意，i为nums下标，是要在[i-k+1]中选到最大值，只需要保证两点
            // 1. 队列头节点需要在[i - k + 1, i]范围内，不符合则要弹出
            while (!deque.isEmpty() && deque.peek() < i - k + 1) {
                deque.poll(); // 默认调用的是pollFirst方法
            }
            // 2.既然是单调，就要保证每次放进去的数字要比末尾的都大，否则也弹出
            while (!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
                // 使用pollFirst和pollLast函数弹出队列头部和尾部的元素
                // [5, 2]如果此时添加的元素的nums[i]=4时，判断2<4，则需要将2弹出，即[5,4]
                deque.pollLast();
            }
            deque.offer(i);
            // 因为单调，当i增长到符合第一个k范围的时候，每滑动一步都将队列头节点放入结果就行
            if (i >= k - 1) { // 这里表示只要符合k=3,i=2时，就可以放入元素
                res[idx++] = nums[deque.peek()];
            }
        }
        return res;
    }

    public static void main(String[] args) {
        Deque<Integer> aa = new ArrayDeque<>();
        aa.offer(1);
        aa.offer(2);
        aa.offer(3);

        Integer integer = aa.pollLast();
        System.out.println(integer);
        Integer integer1 = aa.pollFirst();
        System.out.println(integer1);

        int[] arr = new int[]{1,3,-1,-3,5,3,6,7};
        int k = 3;
        int[] ints = new Code239_MaximumSlidingWindow().maxSlidingWindow1(arr, k);
        System.out.println(Arrays.toString(ints));
    }
}
